function Map() {
    this._items = [];
}

Map.prototype.set = function(key, value) {
    // 使用 findIndex 来查找键是否已经存在
    var index = this._items.findIndex(function(item) {
        return item.key === key;
    });
    // 如果不存在，添加新的键值对
    if (index === -1) {
        this._items.push({ key: key, value: value });
    } else {
        // 如果存在，更新对应的值
        this._items[index].value = value;
    }
};

Map.prototype.get = function(key) {
    // 使用 findIndex 来查找键的位置
    var index = this._items.findIndex(function(item) {
        return item.key === key;
    });
    // 如果找到，返回对应的值
    if (index !== -1) {
        return this._items[index].value;
    }
    // 如果未找到，返回 undefined
    return undefined;
};

Map.prototype.has = function(key) {
    // 使用 findIndex 来查找键的位置
    return this._items.findIndex(function(item) {
        return item.key === key;
    }) !== -1;
};
// 添加 hasValue 方法
Map.prototype.hasValue = function(value) {
    return this._items.some(function(item) {
        return item.value === value;
    });
};

Map.prototype.delete = function(key) {
    // 使用 findIndex 来查找键的位置
    var index = this._items.findIndex(function(item) {
        return item.key === key;
    });
    // 如果找到，从数组中移除
    if (index !== -1) {
        this._items.splice(index, 1);
        return true;
    }
    return false;
};

Map.prototype.forEach = function(callback, thisArg) {
    // 使用 forEach 遍历内部_items数组
    this._items.forEach(function(item) {
        // 调用回调函数，传入值、键和当前 Map 实例
        callback.call(thisArg, item.value, item.key, this);
    }, this);
};

Map.prototype.clear = function() {
    // 将内部数组长度设为 0，实现清空
    this._items.length = 0;
};

// 使用 Object.defineProperty 来模拟 size 属性
Object.defineProperty(Map.prototype, 'size', {
    get: function() {
        // size 属性返回内部数组的长度
        return this._items.length;
    }
});

// 模拟 entries 方法
Map.prototype.entries = function() {
    var index = 0;
    var items = this._items;
    return {
        next: function() {
            if (index < items.length) {
                var item = items[index++];
                return { value: [item.key, item.value], done: false };
            }
            return { value: undefined, done: true };
        }
    };
};

// 模拟 keys 方法
Map.prototype.keys = function() {
    var index = 0;
    var items = this._items;
    return {
        next: function () {
            if (index < items.length) {
                var item = items[index++];
                return {value: item.key, done: false};
            }
            return {value: undefined, done: true};
        }
    }
};
// 模拟 values 方法
Map.prototype.values = function() {
    var index = 0;
    var items = this._items;
    return {
        next: function() {
            if (index < items.length) {
                var item = items[index++];
                return { value: item.value, done: false };
            }
            return { value: undefined, done: true };
        }
    };
};
// constructor 方法，返回 Map 的构造函数
Map.prototype.constructor = function() {
    return Map;
};

// toString 方法，返回 Map 内容的字符串表示
Map.prototype.toString = function() {
    return '{' + this._items.map(function(item) {
        return item.key + ':' + item.value;
    }).join(', ') + '}';
};